// AI服务接口
// 已集成百度千帆API调用

/**
 * 获取百度千帆API密钥（从环境变量中）
 * @returns {string} API密钥
 */
function getApiKey() {
  // 从环境变量中获取API密钥
  const apiKey = import.meta.env.VITE_BAIDU_AI_API_KEY;
  
  if (!apiKey) {
    console.warn('未找到API密钥，请在.env文件中设置VITE_BAIDU_AI_API_KEY');
    // 返回默认示例密钥（实际项目中应该要求用户配置密钥）
    return 'bce-v3/ALTAK-OVXS1wir30oThj94844JC/36e1c6e9cc8e211fe007151098eb36e6b0eb6354';
  }
  
  return apiKey;
}

/**
 * 获取百度千帆AI模型名称
 * @returns {string} 模型名称
 */
function getModelName() {
  // 从环境变量中获取模型名称
  return import.meta.env.VITE_BAIDU_AI_MODEL || 'deepseek-v3.1-250821';
}

/**
 * 获取百度搜索API密钥（从环境变量中）
 * @returns {string} 搜索API密钥
 */
function getSearchApiKey() {
  // 从环境变量中获取搜索API密钥
  const apiKey = import.meta.env.VITE_BAIDU_SEARCH_API_KEY;
  
  if (!apiKey) {
    console.warn('未找到百度搜索API密钥，请在.env文件中设置VITE_BAIDU_SEARCH_API_KEY');
    // 返回默认示例密钥（实际项目中应该要求用户配置密钥）
    return 'your-search-api-key';
  }
  
  return apiKey;
}

/**
 * 获取百度搜索API应用ID（从环境变量中）
 * @returns {string} 搜索API应用ID
 */
function getSearchAppId() {
  // 从环境变量中获取搜索API应用ID
  const appId = import.meta.env.VITE_BAIDU_SEARCH_APP_ID;
  
  if (!appId) {
    console.warn('未找到百度搜索API应用ID，请在.env文件中设置VITE_BAIDU_SEARCH_APP_ID');
    // 返回默认示例应用ID（实际项目中应该要求用户配置）
    return 'your-search-app-id';
  }
  
  return appId;
}

/**
 * 使用百度搜索API进行真实搜索
 * @param {string} query - 搜索查询字符串
 * @returns {Promise<Array>} 搜索结果数组
 */
async function searchWithBaidu(query) {
  try {
    // 使用百度搜索API（也可以根据实际情况替换为其他搜索引擎API）
    // 由于直接调用百度搜索API可能需要服务端签名验证，这里使用服务器代理接口
    // 实际项目中，建议在服务端实现百度搜索API的调用
    const searchApiKey = getSearchApiKey();
    const searchAppId = getSearchAppId();
    
    // 注意：这里使用的是简化的搜索API调用方式，实际项目中需要根据百度搜索API的文档进行配置
    const searchResults = await fetch('https://api.baidu.com/sugrec', {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      params: {
        prod: 'pc',
        wd: query,
        appid: searchAppId,
        apikey: searchApiKey
      }
    }).then(response => response.json())
      .then(data => {
        // 处理搜索结果，转换为统一格式
        if (data.g && Array.isArray(data.g)) {
          return data.g.slice(0, 5).map(item => ({
            title: item.q || '搜索结果',
            snippet: item.s || `${query}的相关搜索结果`,
            url: `https://www.baidu.com/s?wd=${encodeURIComponent(item.q || query)}`
          }));
        }
        return [];
      });
    
    // 如果百度搜索API调用失败，使用备用搜索服务
    if (!searchResults || searchResults.length === 0) {
      // 使用DuckDuckGo搜索API作为备用（无需API密钥）
      const altSearchResults = await fetch(`https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&pretty=1`)
        .then(response => response.json())
        .then(data => {
          const results = [];
          
          // 处理相关话题
          if (data.RelatedTopics && Array.isArray(data.RelatedTopics)) {
            data.RelatedTopics.slice(0, 5).forEach(item => {
              if (item.FirstURL && item.Text) {
                results.push({
                  title: item.Text, 
                  snippet: `关于${query}的相关信息`,
                  url: item.FirstURL
                });
              }
            });
          }
          
          return results;
        });
      
      return altSearchResults;
    }
    
    return searchResults;
  } catch (error) {
    console.error('搜索API调用失败:', error);
    
    // 降级处理：返回基于查询的通用搜索结果
    return [
      {
        title: `${query} - 百度搜索`,
        snippet: `点击查看关于${query}的更多搜索结果和相关信息`,
        url: `https://www.baidu.com/s?wd=${encodeURIComponent(query)}`
      },
      {
        title: `${query} - 必应搜索`,
        snippet: `在必应搜索引擎上查找${query}的相关资讯`,
        url: `https://cn.bing.com/search?q=${encodeURIComponent(query)}`
      },
      {
        title: `${query} - 维基百科`,
        snippet: `查找维基百科上关于${query}的详细介绍`,
        url: `https://zh.wikipedia.org/w/index.php?search=${encodeURIComponent(query)}`
      }
    ];
  }
}

/**
 * 调用百度千帆API获取回答（流式）
 * @param {string} question - 用户问题
 * @param {Function} onChunk - 接收回答片段的回调函数
 * @returns {Promise<void>}
 */
async function callQianfanAPI(question, onChunk) {
  const url = 'https://qianfan.baidubce.com/v2/chat/completions';
  const apiKey = getApiKey();
  
  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${apiKey}`
      },
      body: JSON.stringify({
        model: getModelName(),
        messages: [
          {
            role: 'system',
            content: 'You are a helpful assistant.'
          },
          {
            role: 'user',
            content: question
          }
        ],
        stream: true // 启用流式输出
      })
    });
    
    // 检查响应状态
    if (!response.ok) {
      throw new Error(`API请求失败: ${response.status} ${response.statusText}`);
    }
    
    // 获取响应体的读取器
    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    
    // 处理流式响应
    let accumulatedData = '';
    
    while (true) {
      const { done, value } = await reader.read();
      
      if (done) {
        break;
      }
      
      // 解码当前数据块
      const chunk = decoder.decode(value, { stream: true });
      accumulatedData += chunk;
      
      // 分割数据块（SSE格式通常以"data: "开头）
      const lines = accumulatedData.split('\n');
      
      // 处理每一行
      for (let i = 0; i < lines.length - 1; i++) {
        const line = lines[i].trim();
        
        // 跳过空行
        if (!line) continue;
        
        // 检查是否为结束标记
        if (line === 'data: [DONE]') {
          break;
        }
        
        // 处理以"data: "开头的数据行
        if (line.startsWith('data: ')) {
          try {
            // 解析JSON数据
            const data = JSON.parse(line.substring(6)); // 去掉"data: "前缀
            
            // 提取内容片段
            if (data.choices && data.choices.length > 0) {
              const delta = data.choices[0].delta || {};
              if (delta.content && delta.content.trim()) {
                // 通过回调函数返回内容片段
                onChunk(delta.content);
              }
            }
          } catch (error) {
            console.error('解析流式数据失败:', error, '行内容:', line);
          }
        }
      }
      
      // 保留未处理完的最后一行
      accumulatedData = lines[lines.length - 1];
    }
    
    // 处理最后剩余的积累数据
    if (accumulatedData.trim()) {
      try {
        if (accumulatedData.startsWith('data: ')) {
          const data = JSON.parse(accumulatedData.substring(6));
          if (data.choices && data.choices.length > 0) {
            const delta = data.choices[0].delta || {};
            if (delta.content && delta.content.trim()) {
              onChunk(delta.content);
            }
          }
        }
      } catch (error) {
        console.error('解析最后一块数据失败:', error);
      }
    }
    
  } catch (error) {
    console.error('调用百度千帆API失败:', error);
    // 为了保持用户体验，在发生错误时返回友好提示
    onChunk(`\n\n很抱歉，获取回答时发生错误：${error.message}\n请稍后重试或检查网络连接。`);
    throw error;
  }
}

/**
 * 调用AI服务获取回答（包含联网搜索）
 * @param {string} question - 用户问题
 * @param {Function} onChunk - 接收回答片段的回调函数
 * @param {Function} onSearchResults - 接收搜索结果的回调函数
 * @returns {Promise<void>}
 */
export async function fetchAIResponse(question, onChunk, onSearchResults) {
  try {
    // 1. 执行真实的百度搜索
    const searchResults = await searchWithBaidu(question);
    onSearchResults(searchResults);
    
    // 2. 调用百度千帆API获取回答，并将搜索结果传递给AI模型
    const enhancedQuestion = `${question}\n\n参考以下搜索结果：\n${searchResults.map(result => `标题：${result.title}\n摘要：${result.snippet}\n链接：${result.url}\n\n`).join('')}\n请基于以上搜索结果回答用户的问题。`;
    await callQianfanAPI(enhancedQuestion, onChunk);
  } catch (error) {
    console.error('AI服务调用失败:', error);
    throw new Error('获取AI回答失败，请稍后重试');
  }
}

/**
 * 设置API密钥（在实际项目中使用）
 * @param {string} apiKey - API密钥
 */
export function setApiKey(apiKey) {
  // 在实际项目中，你可能需要将API密钥存储在安全的地方
  // 例如，使用localStorage或专门的配置管理服务
  console.log('设置API密钥:', apiKey ? '已设置' : '未设置')
}